C++ Primer 第 II 部分 C++标准库

IO 库定义了一个与机器无关的 iostate 类型，它提供了表达流状态的完整功能。

标准库还定义了一组函数来查寻这些标志位的状态。操作 good 在所有位置错误位均未置位的情况下返回 true，而 bad、fail 和 eof 则在对应错误被位置时返回 true。此外，在 badbit 被置位时，fail 也会返回 true。这意味着，使用 good 或 fail 时确定流的总体状态的正确方法。实际上，我们将流当作条件使用的代码就等价于!fail()。而 eof 和 bad 操作只能表示特定的错误。

我们已经使用过操纵符 endl，它完成换行并刷新缓冲区的工作。IO 库中还有两个类似的操纵符：flush 和 ends。flush 刷新缓冲区，但不输出任何额外的字符：ends 向缓冲区插入一个空字符，然后刷新缓冲区。

cout << "hi!" << endl;
cout << "hi!" << flush;
cout << "hi!" << ends;

如果想在每次输出操作后都刷新缓冲区，我们可以使用 unitbuf 操纵符。它告诉流在接下来的每次写操作之后都进行一次 flush 操作。而 nounitbuf 操作符则重值流，使其恢复使用正常的系统管理的缓冲区刷新机制：

cout << unitbuf
// 任何输出都立即刷新，无缓冲
count << nounitbuf

警告：如果程序崩溃，输出缓冲区不会被刷新

如果程序异常终止，输出缓冲区是不会被刷新的。当一个程序崩溃后，它所输出的数据很可能停留在输出缓冲区中等待打印。

当调试一个已经崩溃的程序时，需要确认那些你认为已经输出的数据确实已经刷新了。否则，可能将大量的时间浪费在追踪代码为什么没有执行上，而实际上代码已经执行了，只是程序崩溃后缓冲区没有被刷新，输出数据被挂起没有打印而已。

交互式系统通常应该关联输入流和输出流。这意味着所有输出，包括用户提示信息，都会在读取操作之前被打印出来。

tie 有两个重载的版本：一个版本不带参数，返回指向输出流的指针。如果本对象当前关联到一个输出流，则返回的就是指向这个流的指针，如果对象未关联到流，则返回空指针。tie 的第二个版本接受一个指向 ostream 的指针。即，x.tie(&o)将流 x 关掉到输出流 o。

每个流同时最多关联一个流，但多个流可以同时关联到同一个 ostream。

一旦一个文件流已经打开，它就保持与对应文件的关联。实际上，对一个已经打开的文件流调用 open 会失败，并会导致 failbit 被置位。随后的试图使用文件流的操作都会失败。为了将文件流关联到另一个文件，必须首先关闭已经关联的文件。一旦文件成功关闭，我们可以打开新的文件。如果 open 成功，则 open 会设置流的状态，使得 good()为 true。

Note：

当一个 fstream 对象被销毁时，close 会被自动调用。

默认情况下，当我们打开一个 ofstream 时，文件的内容会被丢弃。阻止一个 ofstream 清空给定文件内容的方法是同时指定 app 模式：

ofstream app("file2", ofstream::app); // 隐含为输出模式

WARNING：

保留被 ofstream 打开的文件中已有数据的唯一方法是显式指定 app 或 in 模式。

为了创建一个容器为另一个容器的拷贝，两个容器的类型及其元素类型必须匹配。不过，当传递迭代器参数来拷贝一个范围时，就不要求容器类型是相同的了。而且，新容器和原容器中的元素类型也可以不同，只要能将要拷贝的元素转换为要初始化的容器的元素类型即可。

// 每个容器有三个元素，用给定的初始化器进行初始化
list<string> authors = {"Milton", "Shakespeare", "Austen"};
vector<const char*> articles = {"a", "a", "the"};

list<string> list2(authors);       // 正确：类型匹配
deque<string> authList(authors);   // 错误：容器类型不匹配
vector<string> words(articles);    // 错误：容器类型必须匹配
// 正确：可以将const char*元素转换为string
forward_list<string> words(articles.begin(), articles.end());

除了与关联容器相同的构造函数外，顺序容器（array 除外）还提供另一个构造函数，它接受一个容器大小和一个（可选的）元素初始值。如果我们不提供元素初始值，则标准库会创建一个值初始化器：

vector<int> ivec(10, -1);
list<string> svec(10, "hi!");
forward_list<int> ivec(10);
deque<string> svec(10);

与内置数组一样，标准库 array 的大小也是类型的一部分。当定一个 array 时，除了指定元素类型，还要真定容器大小：

array<int, 42>        // 类型为：保存42个int的数组
array<string, 10>     // 类型为：保存10个string的数组

为了使用 array 类型，我们必须同时指定元素类型和大小。

由于大小时 array 类型的一部分，array 不支持普通的容器构造函数。这些构造函数都会确定容器的大喜爱，要么隐式地，要么显式地。而允许用户向一个 array 构造函数传递大小参数，最好情况下也是多余的，而且容器出错。

值得注意的是，虽然我们不能对内置数组类型进行拷贝或对象赋值操作，但 array 无此限制。

int digs[10] = {0,1,2,3,4,5,6,7,8,9};
int cpy[10] = digs;          // 错误：内置数组不支持拷贝或赋值
array<int, 10> digits = {0,1,2,3,4,5,6,7,8,9};
array<int, 10> copy = digits;    // 正确：只要数组类型匹配即合法

与其他容器一样，array 也要求初始值的类型必须与要创建的容器类型相同。此外 array 要求元素类型和大小也都一样，因为大小时 array 类型的一部分。

赋值运算符要求左边和右边的运算对象具有相同的类型。它将右边运算对象中所有元素拷贝到左边运算对象中。顺序容器（array 除外）还定义了一个名为 assign 的成员，允许我们从一个不同但相容的类型赋值，或者从容器的子序列赋值。assign 操作用参数所指定的元素（的拷贝）替换左边容器中的所有元素。

Note：

除 array 外，swap 不对任何元素进行拷贝、删除或插入操作，因此可以保证在常数时间内完成。

元素不会被移动的事实意味着，除 string 外，指向容器的迭代器、引用和指针在 swap 操作之后都不会失效。它们仍指向 swap 操作之前所指向的那些元素。但在 swap 之后，这些元素已经属于不同的容器了。与其他容器不同，对一个 string 调用 swap 会导致迭代器、引用和指针失效。

与其他容器不同，swap 两个 array 会真正交换它们的元素。因此，交换两个 array 所需的时间与 array 中元素的数目成正比。

因此，对于 array，在 swap 操作之后，指针、引用和迭代器所绑定的元素保持不变，但元素值已经与另一个 array 中对应元素的值进行了交换。

WARNING：

将元素插入到 vector、deque 和 string 中的任何位置都是合法的。然而，这样做可能很耗时。

新标准下，接受元素个数或范围 insert 版本返回指向第一个新加入元素的迭代器。（在旧版本的标准库中，这些操作返回 void）。如果范围为空，不插入任何元素，insert 操作会将第一个参数返回。

通过使用 insert 的返回值，可以在容器中一个特定位置反复插入元素：

list<string> lst;
auto iter = lst.begin();
while (cin >> word)
  iter = iter.insert(iter, word);     // 等价于调用push_front

新标准引入了三个新成员——emplace_front、emplace 和 emplace_back，这些操作构造而不是拷贝元素。这些操作分别对应 push_front、insert 和 push_back，允许我们将元素防止在容器头部、一个指定位置之前或容器尾部。

当我们调用一个 emplace 成员函数时，则是将参数传递给元素类型的构造函数。emplace 成员使用这些参数在容器管理的内存空间中直接构造元素。例如，假定 c 保存 Sales_data（参见 7.1.4 节）元素：

// 在c的末尾构造一个Sales_data对象
// 使用三个参数的Sales_data构造函数
c.emplace_back("978-0590353403", 25, 15.99);
// 错误：没有接受三个参数的push_back版本
c.push_back("978-0590353403", 25, 15.99);
// 正确：创建一个临时的Sales_data对象传递给push_back
c.push_back(Sales_data("978-0590353403", 25, 15.99));

其中对 emplace_back 的调用和第二个 push_back 调用都会创建新的 Sales_data 对象。在调用 emplace_back 时，会在容器管理的内存空间中直接创建对象。而调用 push_back 则会创建一个局部临时对象，并将其压入容器中。

Note：

emplace 函数在容器中直接构造元素。传递给 emplace 函数的参数必须与元素类型的构造函数相匹配。

在容器中访问元素的成员函数（即，front、back、下标和 at）返回的都是引用。

if (!c.empty()) {
  c.front() = 42;      // 将42赋予c中的第一个元素
  auto &v = c.back();  // 获得指向最后一个元素的引用
  v = 1024;            // 改变c中的元素
  auto v2 = c.back();  // v2不是一个引用，它是c.back()的一个拷贝
  v2 = 0;              // 未改变c中的元素
}

提供快速随机访问的容器（string、vector、deque 和 array）也都提供下标运算符。

如果我们希望确保下标时合法的，可以使用 at 成员函数。at 成员函数类似下标运算符，但如果下标越界，at 会抛出一个 out_of_range 异常。

Tip：

如果在一个循环中插入/删除 deque、string 或 vector 中的元素，不要缓存 end 返回的迭代器。

Best Practices：

对于只读取而不改变元素的算法，通常最好使用 cbegin()和 cend()。单是，如果你计划使用算法返回的迭代器来改变元素的值，就需要使用 begin()和 end()的结果作为参数。

WARNING：

哪些值接受一个单一迭代器来表示第二序列的算法，都假定第二个序列至少与第一个序列一样长。

WARNING：

向亩的位置迭代器写入数据的算法假定目地位置足够大，能容纳要写入的元素。

一种保证算法有足够元素空间来容纳输出数据的方法是使用插入迭代器。插入迭代器是一种向容器中添加元素的迭代器。通常情况，当我们通过一个迭代器向容器元素赋值时，只被赋予迭代器指向的元素。而当我们通过一个插入迭代器赋值时，一个与赋值号右侧值相等的元素被添加到了容器中。

我们将在 10.4.1 节中详细介绍插入迭代器的内容。单是，为了展示如何用算法写入数据，我们现在将使用 back_inserter ，它是定义在头文件 interator 中的一个函数。

back_inserter 接受一个指向容器的引用，返回一个与该容器绑定的插入迭代器。当我们通过此迭代器赋值时，赋值运算符会调用 push_back 将一个具有给定值的元素添加到容器中

vector<int> vec;  // 空向量
auto it = back_inserter(vec);  // 通过它赋值会将元素添加到vec中
*it = 42;   // vec中现在有一个元素，值为42

我们常常使用 back_inserter 来创建一个迭代器，作为算法的目的位置来使用。

拷贝算法是另一个向目的位置迭代器指向的输出序列中的元素写入数据的算法。此算法接受三个迭代器，前两个表示一个输入范围，第三个表示目的序列的起始位置。此算法将输入范围中的元素拷贝到目的序列中。

多个算法都提供所谓的“拷贝”版本。这些算法计算新元素的值，但不会将它们防止在输入序列的末尾，而是创建一个新序列保存这些结果。

谓词是一个可调用的表达式，其返回结果是一个能用作条件的值。标准库苏阿法所使用的谓词分为两类： 一元谓词 （意味着它们值接受单一参数）和 二元谓词 （意味着它们有两个参数）。接受谓词参数的算法对输入序列中的元素调用谓词。因此，元素类型必须能转换为谓词的参数类型。

我们可以向一个算法传递任何类别的 可调用对象 。对于一个对象或一个表达式，如果可以对其使用调用运算符（参见 1.5.2），则称它为可调用的。

到目前为止，我们使用过的仅有的两种可调用对象是函数的函数指针。还有其他两种可调用的对象：重载了函数调用运算符的类，我们将在 14.8 节介绍，以及 lambda 表达式 。

一个 lambda 表达式表示一个可调用的代码单元。我们可以将其理解为一个未命名的内联函数。与任何函数类似，一个 lambda 具有一个返回类型、一个参数列表和一个函数体。但与函数不同，lambda 可能定义在函数内部。一个 lambda 表达式具有如下形式

[capture list](parameter list) -> return type { function body }

其中，capture list（捕获列表）是一个 lambda 所在函数中定义的局部变量的列表（通常为空）；return type、parameter list 和 function body 与任何普通函数一样，分别表示返回类型、参数列表和函数体。但是，与普通函数不同，lambda 必须使用尾置返回来指定返回类型。

我们可以忽略参数列表和返回类型，但必须永远包含捕获列表和函数体

auto f = [] { return 42; };

此列中，我们定义了一个可调用对象 f，它不接受参数，返回 42。

在 lambda 中忽略括号和参数列表等价于指定一个空参数列表。在此例中，当调用 f 时，参数列表是空的。如果忽略返回类型，lambda 根据函数体中的代码推断出返回类型。如果函数体只是一个 return 语句，则返回类型从返回的表达式的类型推断而来，否则返回类型为 void。

Note：

如果 lambda 的函数体包含任何单一 return 语句之外的内容，且未指定返回类型，则返回 void。

与一个普通函数调用类型，调用一个 lambda 时给定的实参被用来初始化 lambda 的形参。通常，实参和形参的类型必须匹配。但与普通函数不同，lambda 不能有默认参数。因此，一个 lambda 调用的实参数目永远与形参数目相等。一旦形参初始化完毕，就可以执行函数体了。

虽然一个 lambda 可以出现在一个函数中，使用其局部变量，但它只能使用那些明确指明的变量。一个 lambda 通过将局部变量包含在其捕获列表中来指出将会使用这些变量。捕获列表指引 lambda 在其内部包含访问局部变量所需的信息。

[sz](const string &a)
    { return a.size() > sz; };

Note：

一个 lambda 只有在其捕获列表中捕获一个它所在函数中的局部变量，才能在函数体中使用该变量。

Note：

捕获列表只有用于局部非 static 变量，lambda 可以值接使用局部 static 变量和它所在函数之外声明的名字。

类似参数传递，变量捕获的方式也可以是值或引用。与传值参数类型，采用值捕获的前提是变量可以拷贝。与参数不同，被捕获的变量的值在 lambda 创建时拷贝，而不是调用时拷贝：

void fcn1 {
  size_t v1 = 42;  // 局部变量
  // 将v1拷贝到名为f的可调用对象
  auto f = [v1] { return v1; };
  v1 = 0;
  auto j = f();  // j为42；f保存了我们创建它时v1的拷贝
}

由于被捕获变量的值是在 lambda 创建时拷贝，因此随后对其修改不会影响到 lambda 内对应的值。

void fcn2 {
  size_t v1 = 42;  // 局部变量
  // 对象f2包含v1的引用
  auto f2 = [&v1] { return v1; };
  v1 = 0;
  auto j = f2();  // j为0；f保存v1的引用，而非拷贝
}

引用捕获与返回引用有着相同的问题和限制。如果我们采用引用方式捕获一个变量，就必须确保被引用的对象在 lambda 执行的时候是存在的。lambda 捕获的都是局部变量，这些变量在函数结果后就不复存在了。如果 lambda 可能在函数结束后执行，捕获的引用指向的局部变量已经消失。

我们也可以从一个函数返回 lambda。函数可以值接返回一个可调用对象，或者返回一个类对象，该类含有可调用对象的数据成员。如果函数返回一个 lambda，则与函数不能返回一个局部变量的引用类型四，此 lambda 也不能包含引用捕获。

当以引用方式捕获一个变量时，必须保证在 lambda 执行时变量是存在的。

除了显式列出我们希望使用的来自所在函数的变量之外，还可以让编译器根据 lambda 体种的代码来推断我们要使用哪些变量。为了指示编译器推断捕获列表，应在捕获列表中写一个&或=。&告诉编译器采用捕获引用方式，=则表示采用值捕获方式。

如果我们希望对一部分变量采用值捕获，对其他变量采用引用捕获，可以混合使用隐式捕获和显式捕获。

当我们混合使用隐式捕获和显式捕获时，捕获列表种的第一个元素必须时一个&或=。此符号执行默认捕获方式为引用或值。

当混合使用隐式捕获和显式捕获时，显式捕获的变量必须使用与隐式捕获不同的方式。即，如果隐式捕获是引用方式（使用了&），则显式捕获命名变量必须采用值方式，因此不能在其名字前使用&。类型的，如果隐式捕获采用的值方式（使用了=），则显式捕获命名变量必须采用引用方式，即，在名字前使用&。

默认情况下，对于一个值被拷贝的变量，lambda 不会改变其值。如果我们希望能改变一个被捕获的变量的值，就必须在参数列表首加上关键字 mutable。因此可变 lambda 能省略参数列表：

void fcn3() {
  size_t v1 = 42;   // 局部变量
  // f可以改变它所捕获的变量的值
 auto f = [v1] () mutable { return ++v1; } ;
 v1 = 0;
 auto j = f();  // j为42
}

当我们需要为一个 lambda 定义返回类型时，必须使用尾置返回类型。

可以将 bind 函数看作一个通用的函数适配器（参见 9.6 节），它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。bind 定义在头文件 functional 中。

调用 bind 的一般形式为：

auto newCallable = bind(callable, arg_list);

其中，newCallable 本身是一个可调用对象，arg_list 是一个逗号分隔的参数列表，对应给定的 callable 的参数。即，当我们调用 newCallable 时，newCallable 会调用 callable，并传递给它 arg_list 中的参数。

arg_list 中的参数可能包含形如_n 的名字，其中 n 是一个整数。这些参数是“占位符”，表示 newCallable 的参数，他们占据了传递给 newCallable 的参数的“位置”。数值 n 表示生成的可调用对象中参数的位置：_1 为 newCallable 的第一个参数，_2 为第二个参数，依次类推。

名字_n 都定义在一个名为 placeholders 的命名空间中，而这个命名空间本身定义在 std 命名空间值中。为了使用这些名字，两个命名空间都要写上。与我们的其他例子类似，对 bind 的调用代码假定之前已经适当地使用了 using 声明，例如，_1 对应的 using 声明为：

using std::placeholders::_1;

对每个占位符名字，我们都必须提供一个单独的 using 声明。编写这样的声明很烦人，也很容易出错。可以使用另外一种不同形式的 using 语句（详细内容在 18.2.2 节中介绍），而不是分别声明每个占位符。如下所示：

using namespace namespace_name;

这种形式说明希望所有来自 namespace_name 的名字都可以在我们的程序中直接使用。

如前文所述，我们可以用 bind 修正参数的值。更一般的，可以用 bind 绑定给定可调用对象中的参数或重新安排其顺序。例如，假定 f 是一个可调用对象，它有 5 个此哪哈苏，则下面对 bind 的调用：

// g是一个有两个参数的可调用对象
auto g = bind(f, a, b, _2, c, _1);

生成一个信的可调用对象，它有两个参数，分别用占用符_2 和_1 表示。这个新的可调用对象将他自己的参数作为第三个和第五个参数传递给 f。f 的第一个、第二个和第四个参数分别绑定到给定的值 a、b 和 c 上。

传递给 g 的参数按位置绑定到占位符。即，第个参数绑定到_1，第二个参数绑定到_2，当我们调用 g 时，其第一个参数将被传递给 f 作为最后一个参数，第二个参数将被传递给 f 作为第三个参数。实际上，这个 bind 调用会将

g(_1, _2)

映射为

f(a, b, _2, c, _2)

即，对 g 的调用会调用 f，用 g 的参数代替占位符，再加上绑定参数 a、b 和 c。例如，调用 g(X,Y)会调用

f(a, b, Y, c, X)

默认情况下，bind 的那些不是占位符的参数被拷贝到 bind 返回的可调用对象中。单是，与 lambda 类似，有时对有些绑定的参数我们希望以引用方式传递，或者要绑定参数的类型无法拷贝。例如：

// os是一个局部变量，引用一个输出流
// c是一个局部变量，类型为char
ostream &print(ostream &os, const string &s, char c) {
  return os << s << c;
}

// 错误：不能拷贝os
for_each(words.begin(), words.end(), bind(print, os, _1, '' ));

如果我们希望传递给 bind 一个对象而又不拷贝它，就必须使用标准库 ref 函数：

for_each(words.begin(), words.end(),
         bind(print, ref(os), _1, ' '));

函数 ref 返回一个对象，包含给定的引用，此对象是可以拷贝的。标准库中还有一个 cref 函数，生成一个保存 const 引用的类。与 bind 一样，函数 ref 和 cref 也定义在头文件 functional 中。

当创建一个流迭代器时，必须指定迭代器将要读写的对象类型。一个 istream_iterator 使用>>来读取流。因此，istream_iterator 要读取的类型必须定义了输入运算符。当创建一个 istream_iterator 时，我们可以将它绑定到一个流。当然，我们还可以默认初始化迭代器，这样就创建了一个可以当作尾后值使用的迭代器。

istream_iterator<int> int_it(cin);   // 从cin读取int
istream_iterator<int> int_eof;       // 尾后迭代器
ifstream in("afile");
istream_iterator<string> str_it(in);  // 从"afile"读取字符串

下面时一个用 istream_iterator 从标准输入读取数据，存入一个 vector 的例子：

istream_iterator<int> in_iter(cin);  // 从cin读取int
istream_iterator<int> eof;           // istream尾后迭代器
while (in_iter != eof)
  // 先后置递增，再解引用
  vec.push_back(*in_iter++);

当我们将一个 istream_iterator 绑定到一个流时，标准库并不保证迭代器立即从流读取数据。具体实现可以推迟从流中读取数据，直到我们使用迭代器时才真正读取。标准库中的实现所保证的是，在我们第一次解引用迭代器之前，从流中读取数据的操作已经完成了。对于大多数程序来说，立即读取还是推迟读取没有什么差别。单是，如果我们创建了一个 istream_iterator，没有使用就销毁了，或者我们正在从两个不同的对象同步读取同一个流，那么何时读取可能就很重要了。

我们可以对任何具有输出运算符（<<运算符）的类型定义 ostream_iterator。当创建一个 ostream_iterator 时，我们可以提供（可选的）第二参数，它是一个字符串，在输出每个元素之后都会打印此字符。此字符串必须时一个 C 风格字符串（即，一个字符串字面常量或者一个指向以空字符结尾的字符数组的指针）。必须将 ostream_iterator 绑定到一个指定的流，不容许空的或表示尾后位置的 ostream_iterator。

输入迭代器 ：可以读取序列中的元素。一个与输入迭代器必须支持

• 用于比较两个迭代器的相等和不相等运算符（==、!=）
• 用于推进迭代器的前置和后置递增运算符（++）
• 用于读取元素的解引用（×）：解引用只会出现赋值运算符的右侧
• 箭头运算符（->），等价于(*it).member，即，解引用迭代器，并提取对象的成员

输入迭代器只用于顺序访问。对于一个输入迭代器，*it++保证是有效的，单递增它可能导致所有其他指向流的迭代器失效。其结果就是，不能保证输入迭代器的状态可以保存下来并用来访问元素。因此输入迭代器只能用于单遍扫描算法。算法 find 和 accumulate 要求输入迭代器；而 istream_iterator 是一种输入迭代器。

输出迭代器 ：可以看作输入迭代器功能上的补集——只写而不读元素。输出迭代器必须支持

• 用于推进迭代器的前置和后置递增运算（++）
• 解引用运算符（*），只出现在赋值运算符的左侧（向一个已解引用的输出迭代器赋值，就是将值写入它所指向的元素）

我们只能向一个输出迭代器赋值一次。类似输入迭代器，输出迭代器只能用于单遍扫描算法。用作目的位置的迭代器通常都是输出迭代器。例如，copy 函数的第三个参数就是输出迭代器。ostream_iterator 类型也是输出迭代器。

前向迭代器 ：可以读写元素。这类迭代器只能在序列中沿一个方向移动。前向迭代器支持所有输入和输出迭代器的操作，而且可以多次读写同一个元素。因此，我们可以保存前向迭代器的状态，使用前向迭代器的算法可以对序列进行多遍扫描。算法 repalce 要求前向迭代器，forward_list 上的迭代器是前向迭代器。

双向迭代器 ：可以正向/反向读写序列中的元素。除了支持所有前向迭代器操作之外，双向迭代器还支持前置和后置递减运算符（–）。算法 reverse 要求双向迭代器，除了 forward_list 之外，其他前标准库都提供符合双向迭代器要求的迭代器。

随机访问迭代器 ：提供在常量时间内访问弗烈中任意元素的能力。此类迭代器支持双向迭代器的所有功能，此外还支持表 3.7 中的操作：

• 用于比较两个迭代器相对位置的关系运算符（<、<=、>和>=）
• 迭代器和一个整数值的加减运算（+、+=、-和-=），计算结果是迭代器在序列中前进（或后退）给定整数个元素后的位置
• 用于两个迭代器上的减法元算符（-），得道两个迭代器的距离
• 下标运算符（iter[n]），与*(iter[n])等价

算法 sort 要求随机访问迭代器。array、deque、string 和 vector 的迭代器都是随机访问迭代器，用于访问内置数据元素的指针也是。

dest 参数是一个表示算法可以写入的目的位置的迭代器。算法假定：按其需要写入数据，不管写入多少个元素都是安全的。

WARNING：

向输出迭代器写入数据的算法都假定目标空间足够容纳写入的数据。

如果 desk 是一个指向容器的迭代器，那么算法将输出数据写到容器种已存在的元素内。更常见的情况是，dest 被绑定到一个插入迭代器或是一个 ostream_iterator。插入迭代器会将新元素添加到容器中，因而保证空间元素是足够的。ostream_iterator 会将数据写入到一个输出流，同样不管要写多少个元素都么有问题。

WARNING：

接受单独 beg2 的算法假定从 beg2 开始的序列与 beg 和 end 所表示的范围至少一样大。

接受谓词参数来代替<或==运算符的算法，以及那些不接受额外参数的算法，通常都是重载的函数。函数的一个版本用元素类型的运算符来比较元素；另一个版本接受一个额外谓词参数，啊里代替<或==。

接受一个元素值的算法通常有另一个不同名（不是重载的）版本，该版本接受一个谓词代替元素值。接受谓词参数的算法都有附加的_if 前缀。

find(beg, end, val);       // 查找输入范围中val第一次出现的位置
find_if(beg, end, pred);   // 查找第一个名pred为真的元素

这两个算法提供了命名差异的版本，而非重载版本，因为两个版本的算法都接受相同数目的参数。因此可能产生重载歧义。虽然很罕见，但为了避免任何可能的歧义，标准库选择提供不同名字的版本而不是重载。

默认情况下，重排元素的算法将重排后的元素写回给定的输入序列中。这些算法还提供另一个版本，将元素写到一个指定的输出目的位置。如我们所见，写到额外目的的空间的算法都在名字后面附加了一个_copy（参见 10.2.2 节）：

reverse(beg, end);           // 反转输入范围中的元素
reserve(beg, end, dest);     // 将元素按逆序拷贝到dest

一些算法同时提供_copy 和_if 版本。这些版本接受一个目的位置迭代器和一个谓词。

可以向一个算法提供我们自己定义的比较操作，与之类似，也可以提供 i 自己定义的操作来代替关键字上的<运算符。所提供的操作必须在关键字类型上定义一个 严格弱序 。可以将严格弱序看作”小于等于“，虽然实际定义的操作可能是一个复杂的函数。无论我们怎么样定义比较函数，它必须具备如下基本性质：

• 两个关键字不能同时”小于等于“对方；如果 k1”小于等于“k2,那么 k2 绝不能”小于等于“k1
• 如果 k1”小于等于“k2，且 k2”小于等于“k3，那么 k1 必须”小于等于“k3.
• 如果存在两个关键字，任何一个都不”小于等于“另一个，那么我们称这两个关键字是“等价”的。如果 k1“等价于”k2,且 k2“等价于”k3,那么 k1 必须“等价于”k3.

Note：

在实际编程中，重要的是，如果有一个类型定义了“行为正常”的<运算符，则它可以用作关键字类型。

用来组织一个容器中元素的操作的类型也是该容器类型的一部分。为了指定使用自定义的操作，必须在定义关联容器类型时提供此操作的类型。如前所述，用尖括号指出要定义哪种类型的容器，自定义的操作类型必须在尖括号中紧跟着元素类型给出。

在尖括号中出现的每个类型，就仅仅是一个类型而已。当我们创建一个容器（对象）时，才会以构造函数参数的形式提供真正的比较操作（其类型必须与在尖括号中指定的类型相吻合）。

multiset<Sales_data, decltype(compareIsbn)*>
     bookstore(compareIsbn);

在新标准下，我们可以对返回值进行列表初始化。

虽然 set 类型同时定义了 iterator 和 const_iterator 类型，但两种类型都只允许只读访问 set 中的元素。与不能改变一个 map 元素的关键字一样，一个 set 中的关键字也是 const 的。可以用一个 set 迭代器来读取元素的值，但不能修改。

Note：

当使用一个迭代器遍历一个 map、multimap、set 或 multiset 时，迭代器按关键字升序遍历元素。

我们通常不对关键容器使用泛型算法。关键字 const 这一特性意味着不能将关联容器传递给修改或重排容器元素的算法，因为这类算法需要向元素写入值，而 set 类型中的元素时 const 的，map 中的元素是 pair，其第一个成员是 const 的。

关联容器可用于只读取元素的算法。但是很多这类算法都要搜索序列。由于关联容器中的元素不能通过它们的关键字进行（快速）查找，因此对其使用泛型搜索算法几乎总是一个坏注意。

在实际编程中，如果我们真要对一个关联容器使用算法，要么将它当作一个源序列，要么当作一个目的位置。例如，可以用泛型 copy 算法将元素从一个关联容器拷贝到另一个序列。类似的，可以调用 inserter 将一个插入器绑定到一个关联容器。通过 inserter，我们可以将关联容器当作一个目的位置来调用另一个算法。

对一个 map 进行 insert 操作时，必须记住元素类型是 pair。通常，对于想要插入的数据，并没有一个现成的 pair 对象。可以在 insert 的参数列表中创建一个 pair：

// 向word_count插入word的4种方法
word_count.insert({word, 1});
word_count.insert(make_pair(word, 1));
word_count.insert(pair<string, size_t>(word, 1));
word_count.insert(map<string, size_t>::value_type(word, 1));

如我们所见，在新标准下，创建一个 pair 最简单的方法是在参数列表中使用花括号初始化。也可以调用 make_pair 或显式构造 pair。

insert（或 emplace）返回的值依赖于容器类型和参数。对于不包含重复关键字的容器，添加单一元素的 insert 和 emplace 版本返回一个 pair，告诉我们插入操作是否成功。pair 的 first 成员是一个迭代器，指向具有给定关键字的元素；second 成员是一个 bool 值，指出元素是插入成功还是已经存在于容器中。如果关键字已经在容器中，则 insert 什么事情也不做，且返回值中的 bool 部分为 false。如果关键字不存在，元素被插入容器中，且 bool 值为 true。

对允许重复关键字的容器，接受单个元素的 insert 操作返回一个指向新元素的迭代器。这里无须返回一个 bool 值，因为 insert 总是向这类容器中加入一个新元素。

map 的下标运算符与我们用过的其他下标运算符的另一个不同之处是其返回类型。通常情况下，解引用一个迭代器返回的类型与下标运算符返回的类型是一样的。但对 map 则不然；当对一个 map 进行下标操作时，会获得一个 mapped_type 对象；但当解引用一个 map 迭代器时，会得到一个 value_type 对象。

Note：

与 vector 与 string 不同，map 的下标运算符返回的类型与解引用 map 迭代器得到的类型不同。

如果关键字还未在 map 中，下标运算符会添加一个新元素，这一特定允许我们编写出异常简洁的程序。另一方面，有时指示向直到一个元素是否已在 map 中，但再不存在时并不想添加元素。在这种情况下，就不能使用下标运算符。

lower_bound 返回的迭代器可能指向一个具有给定关键字的元素，但也可能不指向。如果关键在不在容器中，则 lower_bound 会返回关键字的第一个安全插入点——不影响容器中元素顺序的插入位置。

Note：

如果 lower_bound 和 upper_bound 返回相同的迭代器，则给定关键字不在容器中。

最安全的分配和使用动态内存的方法是调用一个名为 make_shared 的标准库函数。此函数在动态内存中分配一个对象并初始化它，返回指向此对象的 shared_ptr。与智能指针一样，make_shared 也定义在头文件 memory 中。

当进行拷贝或赋值操作时，每个 shared_ptr 都会记录有多少个其他 shared_Ptr 指向相同的对象。

我们可以认为每个 shared_ptr 都有一个关联的计数器，通常称其为 引用计数 。无论何时我们拷贝一个 shared_ptr，计数器都会递增。例如，当用一个 shared_ptr 初始化一个另一个 shared_ptr，或将它作为参数传递给一个函数以及作为函数的返回值时，它所关联的计数器就会递增。当我们给 shared_ptr 赋予一个新值或是 shared_ptr 被销毁（例如一个局部的 shared_ptr 离开作用域）时，计数器就会递减。

一旦一个 shared_ptr 的计数器变为 0，它就自动释放自己所管理的对象：

auto r = make_shared<int>(42);  // r指向的int只有一个引用者
r = q;  // 给r赋值，令它指向另一个地址
        // 递增q指向的对象的引用技术
        // 递减r原来指向的对象的引用计数
        // r原来指向的对象已经没有引用者，会自动释放

当指向一个对象的最后一个 shared_ptr 被销毁时，shared_ptr 类会自动销毁此对象。它是通过另一个特殊的成员函数—— 析构函数 完成销毁工作的。类似于构造函数，每个类都有一个析构函数。就像构造函数控制初始化一样，析构函数控制此类型的对象销毁时做什么操作。

shared_ptr 的析构函数会递减它所指向的对象的引用计数。如果引用计数变为 0，shared_ptr 的析构函数将会销毁对象，并释放它占用的内存。

Note：

如果你将 shared_ptr 存放于一个容器中，而后不再需要全部元素，而只使用其中一部分，要记得用 erase 删除不再需要的那些元素。

程序使用动态内存出于以下三种原因之一：

1. 程序不知道自己需要使用多少对象
2. 程序不知道所需要对象的类型
3. 程序需要在多个对象间共享数据

默认情况下，动态分配的对象是默认初始化的，这意味着内置类型或组合类型的对象的值将是未定义的，而类类型对象将用默认构造函数进行初始化。

我们可以使用直接初始方式来初始化一个动态分配的对象。我们可以使用传统的构造方式（使用圆括号），在新标准下，也可以使用列表初始化（使用花括号）。

也可以对动态分配的对象进行值初始化，只需在类型名之后跟一对空括号即可。

对于定义了自己的构造函数的类类型来说，要求值初始化时没有意义的：不管采用什么形式，对象都会通过默认构造函数来初始化。但对于内置类型，两种形式的差别就很大了；值初始化的内置类型对象有着良好定义的值，而默认初始化的对象的值则未定义的。类似的，对于类中那些依赖于编译器合成的默认构造函数的内置类型成员，如果它们未在类内被初始化，那么它们的值也是未定义的。

Best Practices：

出于与变量初始化相同的原因，对动态分配的对象进行初始化通常个好主意。

如果我们提供了一个括号包围的初始化器，就可以使用 auto 从此初始化器来推断我们想要分配的对象的类型。但时，由于编译器要用初始化器的类型来推断要分配的类型，只有当括号中仅有单一初始化器才可以使用 auto：

auto p1 = new auto(obj);      // p指向一个与obj类型相同的对象
                              // 该对象用obj进行初始化
auto p2 = new auto{a, b, c};  // 错误：括号中智能有单个初始化器

类似其他任何 const 对象，一个动态分配的 const 对象必须进行初始化。对于一个定义了默认构造函数的类类型，其 const 动态对象可以隐式初始化，而其他类型的对象就必须显式初始化。由于分配的对象是 const 的，new 返回的指针是一个指向 const 的指针。

一个一个程序用光了它所有可用的内存，new 表达式就会失败。默认情况下，如果 new 不能分配所要求的内存空间，它会抛出一个类型未 bad_alloc 的异常。我们可以改变 new 的方式来阻止它抛出异常：

// 如果分配失败，new返回一个空指针
int *p1 = new int;   // 如果分配失败，new抛出std::bad_alloc
int *p2 = new (nothrow) int;   // 如果分配失败，new返回一个空指针

我们称这种形式的 new 为 定位 new ，其原因我们将在 19.1.2 节中解释。定位 new 表达式允许我们向 new 传递额外的参数。在此例中，我们传递给它一个由标准库定义的名为 nothrow 的对象。如果 nothrow 传递给 new，我们的意图是告诉它不能抛出异常。如果这种形式的 new 不能分配所需内存，它会返回一个指针。bad_alloc 和 nothrow 都定义在头文件 new 中。

我们传递给 delete 的指针必须指向动态分配的内存，或者是一个空指针。释放一块并非 new 分配的内存，或者将相同的指针值释放多次，其行为是未定义的。

虽然一个 const 对象的值不能被改变，但它本身是可以销毁的，如同任何其他动态对象一样，想要释放一个 const 动态对象，只要 delete 指向它的指针即可。

在 delete 之后，指针就变成了人们所说的 空悬指针 ，即，指向一块曾经保存数据对象但现在已经无效的内存指针。

未初始化指针的所有缺点空悬指针也都有。有一种方法可以避免空悬指针问题：在指针即将要离开其作用域之前释放掉它所关联的内存。这样，在指针关联的内存被释放掉之后，就没有机会继续使用指针了。如果我们需要保留指针，可以在 delete 之后将 nullptr 赋予指针，这样就清楚地指出指针不指向任何对象。

shared_ptr 可以协调对象的析构，但这仅限于其自身的拷贝（也是 shared_ptr）之间。这也是为什么我们推荐使用 make_shared 而不是 new 的原因。这样，我们就能在分配对象的同时就将 shared_ptr 与之绑定，从而避免了无意中将同一块内存绑定到多个独立创建的 shared_ptr 上。

当将一个 shared_ptr 绑定到一个普通指针时，我们就将内存的管理责任交给了这个 shared_ptr。一旦这样做了，我们就不应该再使用内置指针来访问 shared_ptr 所指向的内存了。

WARNING：

使用一个内置指针来访问一个智能指针所负责的对象是很危险的，因为我们无法直到对象何时被销毁。

智能指针类型定义了一个名为 get 的函数，它返回一个内置指针，指向智能指针管理的对象。此函数是为了这样一种情况而设计的：我们需要向不使用智能指针的代码传递一个内置指针。使用 get 返回的指针的代码不能 delete 此指针。

WARNING：

get 用来将指针的访问权限传递给代码，你只有在确定代码不会 delete 指针的情况下，才能使用 get。特别是，永远不要用 get 初始化另一个智能指针或为另一个智能指针赋值。

我们可以用 reset 来将一个新的指针赋予一个 shared_ptr。与赋值类似，reset 会更新引用计数，如果需要的话，会释放 p 所指向的对象。reset 成员经常与 unique 一起使用，来控制多个 shared_ptr 共享的对象。在改变底层对象之前，我们检查自己是否是当前对象仅有的用户。如果不是，在改变之前要制作一份新的拷贝。

不能拷贝 unique_ptr 的规则有一个例外：我们可以拷贝或赋值一个将要被销毁的 unique_ptr。最常见的例子就是从函数返回一个 unique_ptr：

unique_ptr<int> clone(int p) {
  // 正确：从int*创建一个unique_ptr<int>
  return unique_ptr<int>(new int(p));
}

还可以返回一个局部对象的拷贝：

unique_ptr<int> clone(int p) {
  unique_ptr<int> ret(new int (p));
  // ...
  return ret;
}

对于两段代码，编译器都知道要返回的对象将要被销毁。在此情况下，编译器执行一种特殊的“拷贝”，我们将在 13.6.2 节中介绍它。

向后兼容：auto_ptr

标准库的较早版本包含了一个名为 auto_ptr 的类，它具有 unique_ptr 的部分特定，但不是全部。特别是，我们不能在容器中保存 auto_ptr，也不能从函数中返回 auto_ptr。

虽然 auto_ptr 是仍是标准库的一部分，但编写程序时应该使用 unique_ptr。